package com.cd.university.service.impl;

import com.cd.university.common.RestResult;
import com.cd.university.common.UniversityConstants;
import com.cd.university.common.obs.ObsUtils;
import com.cd.university.common.utils.MyIdGenerator;
import com.cd.university.common.utils.PageUtil;
import com.cd.university.common.utils.SpringUtil;
import com.cd.university.controller.form.ProjectForm;
import com.cd.university.controller.form.ProjectIdForm;
import com.cd.university.db.mapper.ProjectExamineMapper;
import com.cd.university.db.mapper.ProjectFileMapper;
import com.cd.university.db.mapper.ProjectMapper;
import com.cd.university.db.mapper.ProjectTeamMapper;
import com.cd.university.db.pojo.Project;
import com.cd.university.db.pojo.ProjectExamine;
import com.cd.university.db.pojo.ProjectFile;
import com.cd.university.db.pojo.ProjectTeam;
import com.cd.university.service.ProjectExamineService;
import com.cd.university.service.ProjectService;
import com.cd.university.vo.ProjectVo;
import com.cd.university.vo.UserVo;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionSynchronizationAdapter;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 项目业务逻辑类
 * @author 陈栋
 * @create 2021/10/15 16:59
 */
@Service
@Transactional(rollbackFor = Exception.class)
public class ProjectServiceImpl implements ProjectService {

    @Autowired
    private ProjectMapper projectMapper;

    @Autowired
    private ProjectTeamMapper projectTeamMapper;

    @Autowired
    private ProjectTeamServiceImpl projectTeamService;

    @Autowired
    private ProjectFileMapper projectFileMapper;

    @Autowired
    private ObsUtils obsUtils;

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private ProjectExamineMapper projectExamineMapper;

    @Override
    public RestResult projectApply(ProjectForm form) {
        // 得到Project类
        Project project = projectFormToProject(form);

        // 设置项目的状态为未通过
        project.setStatusId(UniversityConstants.PROJECT_STATUS_NOT_PASS);
        // 调用文号生成器生成文号
        project.setApprovalNumber(MyIdGenerator.getInstance().getRandomNumber());

        // 插入项目
        int row = projectMapper.updateByPrimaryKeySelective(project);

        if (row < 1) {
            return RestResult.failure("创建项目失败");
        }
        Integer userId = form.getLeaderId();

        // 向项目成员表中插入项目
        ProjectTeam projectTeam = new ProjectTeam();
        projectTeam.setProjectId(form.getProjectId());
        projectTeam.setUserId(userId);
        projectTeam.setTeamRole("负责人");
        projectTeam.setStatus(UniversityConstants.PROJECT_TEAM_ACCEPTED);

        // 向项目审核表中插入项目
        ProjectExamine projectExamine = new ProjectExamine();
        BeanUtils.copyProperties(project,projectExamine);
        projectExamine.setExamineStatus("未通过");
        projectExamineMapper.insertSelective(projectExamine);

        // 向项目的团队成员表中插入负责人数据
        projectTeamMapper.insert(projectTeam);

        if (TransactionSynchronizationManager.isActualTransactionActive()) {
            //存在事物，则注册事务同步处理
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                @Override
                public void afterCommit() {
                    // 更新项目审核Service中的缓存
                    ProjectExamineService examineService = SpringUtil.getBean(ProjectExamineService.class);
                    examineService.updateProjectExamine();
                }
            });
        } else {
            // 更新项目审核Service中的缓存
            ProjectExamineService examineService = SpringUtil.getBean(ProjectExamineService.class);
            examineService.updateProjectExamine();
        }

        return RestResult.success("创建项目成功")
                .put("data",project);

    }

    @Override
    public RestResult advanceInsertProject() {
        // TODO: 2021/10/16 使用一个定时线程，定时删除project表中无用的预申请项目
        // 预申请一个新的项目
        Project project = new Project();
        project.setProjectName(String.valueOf(System.currentTimeMillis()));
        projectMapper.advanceInsertProject(project);
        Integer projectId = project.getProjectId();

        return RestResult.success("预申请的项目id")
                .put("data",projectId);
    }

    @Override
    public RestResult searchProjectByUserId(Integer userId, Integer pageNum, Integer pageSize) {
        // 讲项目集合转成项目的vo集合
        List<ProjectVo> projectVoList = getProjectVoList();

        // 双重循环从Redis中的Vo中查询符合所有的项目的id
        ArrayList<ProjectVo> result = new ArrayList<>();
        for (ProjectVo projectVo : projectVoList) {
            List<UserVo> userVos = projectVo.getTeam();
            for (UserVo userVo : userVos) {
                if (userVo.getUserId().equals(userId)) {
                    result.add(projectVo);
                }
            }
        }

        PageInfo pageInfo = pageList(pageNum, pageSize, result);

        return RestResult.success("项目信息")
                .put("data",pageInfo);
    }

    @Override
    public RestResult searchProjectList(List<ProjectIdForm> projectIdList, Integer pageNum, Integer pageSize) {

        ArrayList<ProjectVo> result = new ArrayList<>();

        for (ProjectIdForm form : projectIdList) {
            // 拿到项目id
            Integer projectId = form.getProjectId();
            // 查询项目的所有基本信息
            ProjectVo vo = getProjectVoByProjectId(projectId);

            result.add(vo);
        }

        // 分页
        PageInfo pageInfo = pageList(pageNum, pageSize, result);

        return RestResult.success("分页后的项目数据")
                .put("data",pageInfo);
    }

    @Override
    public RestResult searchAllProject(Integer pageNum, Integer pageSize) {
        // 把所有的项目信息封装成ProjectVo，并且把项目文件放进去
        List<ProjectVo> projectVoList = getProjectVoList();

        if (projectVoList==null) {
            return RestResult.failure("无项目信息");
        }

        PageInfo pageInfo = pageList(pageNum, pageSize, projectVoList);

        return RestResult.success("分页之后的项目信息")
                .put("data",pageInfo);
    }

    @Override
    public RestResult getProjectByDepartmentId(Integer pageNum,
                                               Integer pageSize,
                                               Integer userId,
                                               Integer departmentId) {
        // 根据单位id查询所有的项目
        ArrayList<ProjectVo> tempList = searchProjectByDepartmentId(departmentId);
        ArrayList<ProjectVo> projectVoArrayList = new ArrayList<>();
        // 如果用户id为空那么就查询所有的已经结题的
        if (userId==null) {
            // 从中拿到所有的已经结题的
            for (int i = 0; i < tempList.size(); i++) {
                ProjectVo projectVo = tempList.get(i);
                if (projectVo.getStatusId().equals(UniversityConstants.PROJECT_STATUS_SECOND_PASS)) {
                    projectVoArrayList.add(projectVo);
                }
            }
        }else {
            // 搜索用户的所有项目，得到该用户的所有项目id集合
            List<Integer> projectIdList = projectTeamMapper.searchProjectIdByUserId(userId);
            // 从中拿到所有的已经结题的
            for (int i = 0; i < tempList.size(); i++) {
                ProjectVo projectVo = tempList.get(i);
                if (projectVo.getStatusId().equals(UniversityConstants.PROJECT_STATUS_SUCCESS_PROJECT)
                && projectIdList.contains(projectVo.getProjectId())) {
                    // 从该用户中查询所有的项目，找到与之满足条件的项目
                    projectVoArrayList.add(projectVo);
                }
            }
        }

        PageInfo pageInfo = pageList(pageNum, pageSize, projectVoArrayList);

        return RestResult.success("根据项目的单位id查询的数据")
                .put("data",pageInfo);
    }

    @Override
    public RestResult getProjectByDepartmentAndUserId(Integer pageNum,
                                                      Integer pageSize,
                                                      Integer userId,
                                                      Integer departmentId) {
        // 根据单位id查询所有的项目
        ArrayList<ProjectVo> tempList = searchProjectByDepartmentId(departmentId);
        ArrayList<ProjectVo> projectVoArrayList = new ArrayList<>();

        // 搜索用户的所有项目，得到该用户的所有项目id集合
        List<Integer> projectIdList = projectTeamMapper.searchProjectIdByUserId(userId);
        // 从中拿到所有的可以进行结题的
        for (int i = 0; i < tempList.size(); i++) {
            ProjectVo projectVo = tempList.get(i);
            if (projectIdList.contains(projectVo.getProjectId())) {
                // 从该用户中查询所有的项目，找到与之满足条件的项目
                projectVoArrayList.add(projectVo);
            }
        }

        PageInfo pageInfo = pageList(pageNum, pageSize, projectVoArrayList);

        return RestResult.success("根据项目的单位id查询的数据")
                .put("data",pageInfo);
    }

    @Override
    public RestResult getProjectByName(Integer pageNum,
                                               Integer pageSize,
                                               Integer userId,
                                               String projectName) {
        // 通过项目名(前缀)拿到所有的项目
        ArrayList<ProjectVo> projectVoByName = searchProjectVoByName(projectName);

        // 创建一个目标的ProjectVo集合对象
        ArrayList<ProjectVo> tempList = new ArrayList<>();

        if (userId!=null) {
            for (int i = 0; i < projectVoByName.size(); i++) {
                ProjectVo projectVo = projectVoByName.get(i);
                if (projectVo.getLeaderId().equals(userId)) {
                    tempList.add(projectVo);
                }
            }
        }else {
            for (int i = 0; i < projectVoByName.size(); i++) {
                ProjectVo projectVo = projectVoByName.get(i);
                tempList.add(projectVo);
            }
        }

        // 进行分页
        PageInfo pageInfo = pageList(pageNum, pageSize, tempList);
        return RestResult.success("查询数据如下")
                .put("data",pageInfo);
    }

    @Override
    public RestResult getProjectByStIdAndDeId(Integer userId,
                                              Integer statusId,
                                              Integer departmentId,
                                              Integer pageNum,
                                              Integer pageSize) {
        ArrayList<ProjectVo> list = null;
        RestResult result;
        if (statusId==null && departmentId==null) {
            result =  searchProjectByUserId(userId, pageNum, pageSize);
        }
        else if (statusId==null) {
            result =  getProjectByDepartmentAndUserId(pageNum, pageSize, userId, departmentId);
        }
        else if (departmentId==null) {
            list = searchByProjectInfo(userId, statusId);
            PageInfo pageInfo = PageUtil.startPage(pageNum, pageSize, list);
            result = RestResult.success("根据状态id搜索的项目如下")
                    .put("data",pageInfo);
        }
        else {
            list = searchByProjectInfo(userId,departmentId,statusId);
            PageInfo pageInfo = PageUtil.startPage(pageNum, pageSize, list);
            result = RestResult.success("根据状态id以及部门id搜索的项目如下")
                    .put("data",pageInfo);
        }

        return result;
    }

    /**
     * 通过项目的名称搜索所有的项目
     * @param projectName 项目名
     * @return 项目Vo集合
     */
    public ArrayList<ProjectVo> searchProjectVoByName(String projectName) {
        List<ProjectVo> projectVoList = getProjectVoList();

        ArrayList<ProjectVo> list = new ArrayList<>();

        for (ProjectVo projectVo : projectVoList) {
            // 如果项目名包含projectName那么就添加到集合中
            if (projectVo.getProjectName().contains(projectName)) {
                list.add(projectVo);
            }
        }

        return list;
    }

    /**
     * 根据项目的单位id搜索所有的项目
     * @param departmentId 项目的单位id
     * @return 项目集合
     */
    public ArrayList<ProjectVo> searchProjectByDepartmentId(Integer departmentId) {
        // 从redis中拿到所有的项目
        ValueOperations operations = redisTemplate.opsForValue();
        List<ProjectVo> projectVos = (List<ProjectVo>) operations.get("projectVos");
        // 根据单位id查询所有的项目
        ArrayList<ProjectVo> projectDepartmentList = new ArrayList<>();
        for (ProjectVo projectVo : projectVos) {
            if (projectVo.getDepartmentId().equals(departmentId)) {
                projectDepartmentList.add(projectVo);
            }
        }

        return projectDepartmentList;
    }

    public ArrayList<ProjectVo> searchByProjectInfo(Integer userId,Integer statusId) {
        return searchByProjectInfo(userId,null,statusId);
    }

    public ArrayList<ProjectVo> searchByProjectInfo(Integer userId, Integer departmentId, Integer statusId) {
        List<ProjectVo> projectVos = getProjectVoList();

        ArrayList<ProjectVo> list = new ArrayList<>();
        if (departmentId==null) {
            // 根据项目的状态查找用户的项目
            for (ProjectVo vo : projectVos) {
                if (vo.getStatusId().equals(statusId)) {
                    // 获得项目的所有的成员
                    List<UserVo> userVos = vo.getTeam();
                    // 遍历成员判断userId是否在userVos中
                    for (UserVo userVo : userVos) {
                        if (userVo.getUserId().equals(userId)) {
                            list.add(vo);
                        }
                    }
                }
            }
        }else {
            // 根据项目的状态以及部门id查找用户的项目
            for (ProjectVo vo : projectVos) {
                if (vo.getStatusId().equals(statusId) && vo.getDepartmentId().equals(departmentId)) {
                    // 获得项目的所有的成员
                    List<UserVo> userVos = vo.getTeam();
                    // 遍历成员判断userId是否在userVos中
                    for (UserVo userVo : userVos) {
                        if (userVo.getUserId().equals(userId)) {
                            list.add(vo);
                        }
                    }
                }
            }
        }
        return list;
    }

    /**
     * 通过项目集合查询集合中每一个项目的所有文件，并且封装成ProjectVo对象
     * @param projectList 项目集合
     * @return ProjectVo对象集合
     */
    public List<ProjectVo> getProjectVoList(List<Project> projectList) {
        // 从redis中拿到所有的项目Vo
        ValueOperations opsForValue = redisTemplate.opsForValue();
        List<ProjectVo> projectVos = (List<ProjectVo>) opsForValue.get("projectVos");
        return projectVos;
    }

    /**
     * 通过项目集合查询集合中每一个项目的所有文件，并且封装成ProjectVo对象
     * @return ProjectVo对象集合
     */
    public List<ProjectVo> getProjectVoList() {
        return getProjectVoList(null);
    }

    /**
     * 从缓存中查询项目
     * @param projectId 项目id
     * @return 项目Vo信息
     */
    public ProjectVo getProjectVoByProjectId(Integer projectId) {
        ValueOperations operations = redisTemplate.opsForValue();
        List<ProjectVo> projectVos = (List<ProjectVo>) operations.get("projectVos");

        for (ProjectVo projectVo : projectVos) {
            if (projectVo.getProjectId().equals(projectId)) {
                return projectVo;
            }
        }

        throw new RuntimeException("在Redis缓存中找不到该项目的Vo");
    }


    /**
     * 从缓存中查询一个项目中的所有文件
     * @param projectId 项目id
     * @return 项目文件的集合
     */
    public List<ProjectFile> getProjectFileByProjectId(Integer projectId) {
        ValueOperations operations = redisTemplate.opsForValue();
        List<ProjectFile> projectFiles = (List<ProjectFile>) operations.get("projectFiles");

        List<ProjectFile> projectFileList = new ArrayList<>();
        for (ProjectFile projectFile : projectFiles) {
            if (projectFile.getProjectId().equals(projectId)) {
                projectFileList.add(projectFile);
            }
        }

        return projectFileList;
    }

    /**
     * 获得分页的数据
     * @param pageNum 页数
     * @param pageSize 每页的个数
     * @param list 集合
     * @return 分页后的数据
     */
    public PageInfo pageList(Integer pageNum,
                              Integer pageSize,
                              List list) {
        // 使用自定义的工具类进行分页处理
        PageInfo pageInfo = PageUtil.startPage(pageNum, pageSize, list);
        return pageInfo;
    }

    /**
     * 把ProjectForm转成project的pojo类
     * @param form ProjectForm
     * @return Prject的pojo类
     */
    public Project projectFormToProject(ProjectForm form) {
        Project project = new Project();

        BeanUtils.copyProperties(form,project);
        return project;
    }

    /**
     * 获得项目的文件夹名称
     * @param projectId 项目id
     * @return 项目的文件夹名称
     */
    public String getFolderName(Integer projectId) {
        // 文件夹名称
        String folder = UniversityConstants.PROJECT_FOLDER + "/" + projectId;
        return folder;
    }

    /**
     * 把Project转成ProjectVo
     * @param project 项目基本信息
     * @return ProjectVo对象
     */
    public ProjectVo projectToProjectVo(Project project) {
        ProjectVo projectVo = new ProjectVo();

        BeanUtils.copyProperties(project,projectVo);
        return projectVo;
    }

    /**
     * 拿到项目文件的Url
     * @param fileName 文件名
     * @param projectId 项目id
     * @return 文件的url
     */
    public String getFileUrl(String fileName,Integer projectId) {
        String fileUrl = obsUtils.getFileUrl(fileName, getFolderName(projectId));
        return fileUrl;
    }

    /**
     * 异步定时删除预申请的项目,默认为30分钟
     */
    @Override
    @Async
    @Scheduled(fixedRate = 1000 * 60 * 30)
    public void deleteAdvanceProject() {
        projectMapper.deleteAdvanceProject();
    }

    /**
     * 异步查询所有的项目以及所有的项目文件，存在缓存中
     * 默认为1小时，更新一次
     */
    @Override
    @Async
    @Scheduled(fixedRate = 1000 * 60 * 60)
    public void loadProjectsToRedis() {
        // 获得操控redis的工具
        ValueOperations opsForValue = redisTemplate.opsForValue();

        // 查到所有的项目信息
        List<Project> projects = projectMapper.searchAllProject();
        // 把项目的信息放到redis中
        opsForValue.getAndSet("projects",projects);

        // 查询所有的项目文件
        List<ProjectFile> projectFiles = null;

        if ((projectFiles = projectFileMapper.searchAllProjectFile())!=null) {
            opsForValue.getAndSet("projectFiles",projectFiles);

            // 把所有的项目封装成项目Vo放入Redis中
            List<ProjectVo> projectVos = loadProjectVoToRedis(projects);
            // 把项目的Vo对象放到redis中
            opsForValue.getAndSet("projectVos",projectVos);
        }

    }

    /**
     * 通过项目集合查询集合中每一个项目的所有文件，并且封装成ProjectVo对象
     * @param projectList 项目集合
     * @return ProjectVo对象集合
     */
    public List<ProjectVo> loadProjectVoToRedis(List<Project> projectList) {
        List<ProjectVo> result = new ArrayList<>();

        for (Project project : projectList) {
            ProjectVo projectVo = projectToProjectVo(project);

            HashMap<String, String> fileMap = new HashMap<>();
            // 查询该项目的所有文件
            List<ProjectFile> projectFiles = getProjectFileByProjectId(project.getProjectId());
            for (ProjectFile projectFile : projectFiles) {
                if ("logo".equals(projectFile.getFileId())) {
                    fileMap.put("logo",projectFile.getPath());
                }else {
                    fileMap.put(projectFile.getFileName(),projectFile.getPath());
                }
            }
            projectVo.setFileMap(fileMap);

            // 查询项目的所有的成员信息
            List<UserVo> userVos = (List<UserVo>) projectTeamService.searchProjectUsers(project.getProjectId()).get("data");
            projectVo.setTeam(userVos);

            result.add(projectVo);
        }

        return result;
    }

    /**
     * 如果添加了新的项目或者项目文件更新redis中的项目
     * @param project 项目
     */
    public void updateRedis(Project project) {
        updateRedis(project,null);
    }

    public void updateRedis(ProjectFile projectFile) {
        updateRedis(null,projectFile);
    }

    @Async
    public void updateRedis(Project project, ProjectFile projectFile) {
        // 获得操控redis的工具
        ValueOperations opsForValue = redisTemplate.opsForValue();

        if (project!=null) {
            List<Project> projects = getProjectsFromRedis();
            projects.add(project);

            // 拿到所有的Redis中的ProjectVo对象
            List<ProjectVo> projectVos = (List<ProjectVo>) opsForValue.get("projectVos");
            projectVos.add(projectToProjectVo(project));

            // 把项目的信息放到redis中
            opsForValue.getAndSet("projects",projects);
        }

        if (projectFile!=null) {
            List<ProjectFile> projectFiles = getProjectFilesFromRedis();
            // 向Redis中增加新添的Project
            projectFiles.add(projectFile);
            // 把项目的文件放到redis中
            opsForValue.getAndSet("projectFiles",projectFiles);

            // 更新Redis中的ProjectVo中的fileMap
            List<ProjectVo> projectVos = (List<ProjectVo>) opsForValue.get("projectVos");
            // 使用迭代器更新VoList中的projectVo中的FileMap
            Iterator<ProjectVo> iterator = projectVos.iterator();
            while (iterator.hasNext()) {
                ProjectVo projectVo = iterator.next();
                if (projectVo.getProjectId().equals(projectFile.getProjectId())) {
                    HashMap<String, String> map = projectVo.getFileMap();
                    map.put(projectFile.getFileName(), projectFile.getPath());
                    projectVo.setFileMap(map);
                    opsForValue.getAndSet("projectVos",projectVos);
                    break;
                }
            }
        }

    }

    /**
     * 更新Redis中的Project以及ProjectVo以及ProjectFile的状态
     * @param statusId 状态
     * @param projectId 项目id
     * @param fileId 项目文件id
     * @param projectName 项目文件名称
     */
    @Async
    public void updateStatusFromRedis(Integer statusId, Integer projectId, String fileId, String projectName) {
        // 从redis中拿到所有的项目
        ValueOperations opsForValue = redisTemplate.opsForValue();

        // 更新Redis中的项目表
        List<Project> projects = (List<Project>) opsForValue.get("projects");
        Iterator<Project> iterator = projects.iterator();
        for (Project project : projects) {
            // 根据项目的主键id查找
            if (projectId!=null && project.getProjectId().equals(projectId)) {
                // 先从List中删除删除本项目
                projects.remove(project);
                // 把该项目的状态重新填写
                project.setStatusId(statusId);
                // 把修改之后的项目重新放入
                projects.add(project);

                // 重新放回Redis中的项目
                opsForValue.getAndSet("projects",projects);
                break;
            }

            // 根据项目的名称查找并更新
            if (projectName!=null && project.getProjectName().equals(projectName)) {
                // 先从List中删除删除本项目
                projects.remove(project);
                // 把该项目的状态重新填写
                project.setStatusId(statusId);
                // 把修改之后的项目重新放入
                projects.add(project);

                // 重新放回Redis中的项目
                opsForValue.getAndSet("projects",projects);
                break;
            }
        }

        // 更Redis中的项目Vo对象
        List<ProjectVo> projectVos = (List<ProjectVo>) opsForValue.get("projectVos");
        for (ProjectVo projectVo : projectVos) {
            // 根据项目的主键id查找
            if (projectId!=null && projectVo.getProjectId().equals(projectId)) {
                projectVo.setStatusId(statusId);

                // 把修改之后所有集合放入到新的集合之后
                ArrayList<ProjectVo> voArrayList = new ArrayList<>();
                voArrayList.addAll(projectVos);
                // 重新放到Redis里面
                opsForValue.getAndSet("projectVos",voArrayList);

                break;
            }

            // 根据项目的名称id查找
            if (projectName!=null && projectVo.getProjectName().equals(projectName)) {
                projectVo.setStatusId(statusId);

                // 把修改之后所有集合放入到新的集合之后
                ArrayList<ProjectVo> voArrayList = new ArrayList<>();
                voArrayList.addAll(projectVos);
                // 重新放到Redis里面
                opsForValue.getAndSet("projectVos",voArrayList);

                break;
            }
        }

        // 如果不需要更新文件那么直接返回
        if (fileId==null) {
            return;
        }

        // 更新Redis中的项目文件表
        List<ProjectFile> projectFiles = (List<ProjectFile>) opsForValue.get("projectFiles");
        for (ProjectFile projectFile : projectFiles) {
            if (projectFile.getFileId().equals(fileId)) {
                // 判断项目的形式是否已经通过了结题申请的审核，如果是，那么文件的状态id就为通过接替审核
                statusId = statusId.equals(UniversityConstants.PROJECT_STATUS_FINALIZE_PROJECT) ? UniversityConstants.PROJECT_FILE_PASS : UniversityConstants.PROJECT_FILE_NOT_PASS;
                projectFile.setStatus(statusId);

                ArrayList<ProjectFile> files = new ArrayList<>();
                files.addAll(projectFiles);
                // 重新放回Redis中的项目
                opsForValue.getAndSet("projectFiles",files);
                break;
            }
        }
    }

    /**
     * 从Redis中拿到所有的项目
     * @return 所有的项目
     */
    public List<Project> getProjectsFromRedis() {
        // 从redis中拿到所有的项目
        ValueOperations opsForValue = redisTemplate.opsForValue();
        List<Project> projects = (List<Project>) opsForValue.get("projects");
        // 如果redis中没有数据，那么从数据库中查询
        if (projects==null && projects.size()==0) {
            // 查到所有的项目信息
            projects = projectMapper.searchAllProject();
            // 把项目的信息放到redis中
            opsForValue.getAndSet("projects",projects);
        }

        return projects;
    }

    /**
     * 从Redis中拿到所有的项目文件
     * @return 所有的项目文件
     */
    public List<ProjectFile> getProjectFilesFromRedis() {
        ValueOperations opsForValue = redisTemplate.opsForValue();
        List<ProjectFile> projectFiles = (List<ProjectFile>) opsForValue.get("projectFiles");
        if (projectFiles==null || projectFiles.size()==0) {
            projectFiles = projectFileMapper.searchAllProjectFile();
            opsForValue.getAndSet("projectFiles",projectFiles);
        }
        return projectFiles;
    }

    /**
     * 从Redis中拿到projectVos
     * @return projectVos集合
     */
    public List<ProjectVo> getProjectVosFromRedis() {
        ValueOperations opsForValue = redisTemplate.opsForValue();
        List<ProjectVo> projectVos = (List<ProjectVo>) opsForValue.get("projectVos");
        return projectVos;
    }

}
